package org.aplombh.java.awcing.basic.struct.hash;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 维护一个集合，支持如下几种操作：
 * <p>
 * I x，插入一个数 x；
 * Q x，询问数 x 是否在集合中出现过；
 * 现在要进行 N 次操作，对于每个询问操作输出对应的结果。
 * <p>
 * 输入格式
 * 第一行包含整数 N，表示操作数量。
 * <p>
 * 接下来 N 行，每行包含一个操作指令，操作指令为 I x，Q x 中的一种。
 * <p>
 * 输出格式
 * 对于每个询问指令 Q x，输出一个询问结果，如果 x 在集合中出现过，则输出 Yes，否则输出 No。
 * <p>
 * 每个结果占一行。
 * <p>
 * 数据范围
 * 1≤N≤10^5
 * −10^9≤x≤10^9
 * 输入样例：
 * 5
 * I 1
 * I 2
 * I 3
 * Q 2
 * Q 5
 * 输出样例：
 * Yes
 * No
 */

public class HashTable_840 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);


//        HashTable_Chaining hashTable = new HashTable_Chaining();
//
//        int n = scanner.nextInt();
//        while (n-- != 0) {
//            String op = scanner.next();
//            int x = scanner.nextInt();
//            if (op.charAt(0) == 'I')
//                hashTable.insert(x);
//            else if (hashTable.find(x)) System.out.println("yes");
//            else System.out.println("No");
//        }

        HashTable_OpenAddress hashTable = new HashTable_OpenAddress();
        int n = scanner.nextInt();
        while (n-- != 0) {
            String op = scanner.next();
            int x = scanner.nextInt();
            if (op.charAt(0) == 'I')
                hashTable.insert(x);
            else if (hashTable.getByIndex(hashTable.find(x)) != HashTable_OpenAddress.notExit) System.out.println("yes");
            else System.out.println("No");

        }
    }
}

// 开放地址法
class HashTable_OpenAddress {
    public static final int N = 200003;  // 超过2*10^5的最小质数 the smallest prime number greater than 2*10^5
    public static final int notExit = 0x3f3f3f3f;
    int[] hashTable;  // 存指针的下标 Stores subscripts of pointers
    int index;  // 下标 index


    public HashTable_OpenAddress() {
        init();
    }

    public void init() {
        hashTable = new int[N];
        Arrays.fill(hashTable, notExit);
        index = 0;
    }

    public void insert(int x) {
        // 找到x应该插入的位置，如果已经存在x，找到x的位置
        int k = find(x);
        hashTable[k] = x;
    }

    public int find(int x) {
        // 限定在0~N的范围
        int k = (x % N + N) % N;
        // 如果当前位置存在值且值不为x
        // 往当前节点的后一个节点遍历
        while (hashTable[k] != notExit && hashTable[k] != x) {
            k++;
            // 遍历到尾部，从头开始
            if (k == N) k = 0;
        }
        // 分两种情况 1：遍历到不存在的点 返回的是下一个可用节点
        //          2：当前节点存在但是值为x，两值相同，就是当前位置，不用变了
        return k;
    }

    public int getByIndex(int k){
        return hashTable[k];
    }
}

// 链地址法
class HashTable_Chaining {
    public static final int N = 100003;  // 超过10^5的最小质数 the smallest prime number greater than 10^5

    int[] hashTable;  // 存指针的下标 Stores subscripts of pointers
    int[] element;  // 存元素的值 Store the value of the element
    int[] next;  // 存指针 Stores pointers
    int index;  // 下标 index

    public HashTable_Chaining() {
        init();
    }

    public void init() {
        hashTable = new int[N];
        Arrays.fill(hashTable, -1);

        element = new int[N];

        next = new int[N];

        index = 0;
    }

    /**
     * 求大于n的最小质数
     * Find the smallest prime number greater than n
     *
     * @param n the number
     * @return smallest prime number greater than n
     */
    public static int primeNumber(int n) {
        for (int i = n; ; i++) {
            boolean flag = true;
            for (int j = 2; j * j <= i; j++)
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            if (flag) {
                return i;
            }
        }
    }

    public void insert(int x) {
        int k = (x % N + N) % N;
        // 将x存入element中 Put x into element arrays
        element[index] = x;
        // 将hashTable中存储的下标存储进next中 Store the subscripts stored in hashTable into next
        next[index] = hashTable[k];
        // 将指针下标存进bashTable中 Store the subscript of pointer into the bashTable
        hashTable[k] = index++;

    }

    public boolean find(int x) {
        int k = (x % N + N) % N;
        for (int i = hashTable[k]; i != -1; i = next[i])  // 遍历hashTable
            if (element[i] == x)
                return true;
        return false;
    }
}
